// import { _decorator, Component, Node, Prefab, Label, Button } from 'cc';
// import { nodePoolManager, INodePoolConfig } from './NodepoolManager';

// const { ccclass, property } = _decorator;

// /**
//  * 节点池使用示例
//  * 演示如何在实际项目中使用 NodePoolManager
//  */
// @ccclass('NodepoolExample')
// export class NodepoolExample extends Component {
//     @property(Prefab)
//     itemPrefab: Prefab = null!;

//     @property(Node)
//     container: Node = null!;

//     @property(Label)
//     statsLabel: Label = null!;

//     private activeItems: Node[] = [];
//     private readonly POOL_ID = 'example_item';

//     async onLoad() {
//         // 配置节点池
//         const config: INodePoolConfig = {
//             preloadCount: 10,
//             maxCount: 100,
//             enableStats: true,
//             onNodeCreate: (node) => {
//                 console.log('创建新节点:', node.uuid);
//             },
//             onNodeReuse: (node) => {
//                 console.log('重用节点:', node.uuid);
//                 node.active = true;
//             },
//             onNodeRecycle: (node) => {
//                 console.log('回收节点:', node.uuid);
//                 node.active = false;
//             },
//         };

//         // 创建节点池
//         nodePoolManager.createPool(this.POOL_ID, this.itemPrefab, config);

//         // 预加载
//         await nodePoolManager.preloadPool(this.POOL_ID);

//         console.log('节点池初始化完成');
//         this.updateStats();
//     }

//     start() {
//         this.setupButtons();
//     }

//     /**
//      * 设置测试按钮
//      */
//     private setupButtons() {
//         // 假设场景中有这些按钮
//         const addBtn = this.node.getChildByName('AddButton');
//         const removeBtn = this.node.getChildByName('RemoveButton');
//         const clearBtn = this.node.getChildByName('ClearButton');
//         const statsBtn = this.node.getChildByName('StatsButton');

//         if (addBtn) {
//             addBtn.on(Button.EventType.CLICK, this.addItem, this);
//         }
//         if (removeBtn) {
//             removeBtn.on(Button.EventType.CLICK, this.removeItem, this);
//         }
//         if (clearBtn) {
//             clearBtn.on(Button.EventType.CLICK, this.clearAllItems, this);
//         }
//         if (statsBtn) {
//             statsBtn.on(Button.EventType.CLICK, this.printStats, this);
//         }
//     }

//     /**
//      * 添加一个节点
//      */
//     public addItem() {
//         const item = nodePoolManager.getNode(this.POOL_ID);
//         if (item) {
//             this.container.addChild(item);
            
//             // 设置随机位置
//             const x = (Math.random() - 0.5) * 500;
//             const y = (Math.random() - 0.5) * 300;
//             item.setPosition(x, y, 0);

//             // 添加标签显示索引
//             const label = item.getComponentInChildren(Label);
//             if (label) {
//                 label.string = `Item ${this.activeItems.length}`;
//             }

//             this.activeItems.push(item);
//             this.updateStats();
//         } else {
//             console.warn('无法获取节点，可能已达到最大数量');
//         }
//     }

//     /**
//      * 移除一个节点
//      */
//     public removeItem() {
//         if (this.activeItems.length > 0) {
//             const item = this.activeItems.pop();
//             if (item) {
//                 nodePoolManager.putNode(item, this.POOL_ID);
//                 this.updateStats();
//             }
//         }
//     }

//     /**
//      * 清除所有节点
//      */
//     public clearAllItems() {
//         nodePoolManager.putNodes(this.activeItems, this.POOL_ID);
//         this.activeItems = [];
//         this.updateStats();
//     }

//     /**
//      * 打印统计信息
//      */
//     public printStats() {
//         nodePoolManager.printStats();
//         this.updateStats();
//     }

//     /**
//      * 更新统计显示
//      */
//     private updateStats() {
//         const stats = nodePoolManager.getPoolStats(this.POOL_ID);
//         if (stats && this.statsLabel) {
//             this.statsLabel.string = 
//                 `池大小: ${stats.poolSize}\n` +
//                 `活跃节点: ${stats.activeCount}\n` +
//                 `总创建: ${stats.totalCreated}\n` +
//                 `总获取: ${stats.totalGet}\n` +
//                 `总回收: ${stats.totalRecycle}\n` +
//                 `命中率: ${(stats.hitRate * 100).toFixed(2)}%`;
//         }
//     }

//     /**
//      * 批量添加节点（压力测试）
//      */
//     public addBatchItems(count: number = 10) {
//         for (let i = 0; i < count; i++) {
//             this.addItem();
//         }
//     }

//     /**
//      * 模拟游戏循环中的节点获取和回收
//      */
//     public simulateGameLoop() {
//         this.schedule(() => {
//             // 随机添加或移除
//             if (Math.random() > 0.5 && this.activeItems.length < 20) {
//                 this.addItem();
//             } else if (this.activeItems.length > 0) {
//                 this.removeItem();
//             }
//         }, 0.1, 100);
//     }

//     onDestroy() {
//         // 清理节点池
//         this.clearAllItems();
//         // 如果不再需要这个池，可以完全移除
//         // nodePoolManager.removePool(this.POOL_ID);
//     }
// }

// /**
//  * MVVM 架构示例
//  */
// @ccclass('MVVMListExample')
// export class MVVMListExample extends Component {
//     @property(Prefab)
//     listItemPrefab: Prefab = null!;

//     @property(Node)
//     listContainer: Node = null!;

//     private listItems: Node[] = [];
//     private readonly LIST_POOL_ID = 'mvvm_list_item';

//     async onLoad() {
//         // 创建列表项节点池
//         nodePoolManager.createPool(this.LIST_POOL_ID, this.listItemPrefab, {
//             preloadCount: 20,
//             maxCount: 100,
//             onNodeReuse: (node) => {
//                 // 重置节点状态
//                 node.active = true;
//                 node.setScale(1, 1, 1);
//             },
//         });

//         await nodePoolManager.preloadPool(this.LIST_POOL_ID);
//     }

//     /**
//      * 刷新列表数据
//      */
//     public refreshList(data: any[]) {
//         // 先回收所有旧节点
//         this.clearList();

//         // 创建新的列表项
//         data.forEach((itemData, index) => {
//             const item = nodePoolManager.getNode(this.LIST_POOL_ID);
//             if (item) {
//                 this.listContainer.addChild(item);
                
//                 // 绑定数据到视图组件
//                 const itemView = item.getComponent('ListItemView');
//                 if (itemView && typeof itemView['bindData'] === 'function') {
//                     itemView['bindData'](itemData);
//                 }

//                 // 设置位置
//                 item.setPosition(0, -index * 100, 0);
                
//                 this.listItems.push(item);
//             }
//         });
//     }

//     /**
//      * 清空列表
//      */
//     private clearList() {
//         nodePoolManager.putNodes(this.listItems, this.LIST_POOL_ID);
//         this.listItems = [];
//     }

//     onDestroy() {
//         this.clearList();
//     }
// }

// /**
//  * ECS 架构示例
//  */
// @ccclass('ECSEntityExample')
// export class ECSEntityExample extends Component {
//     @property(Prefab)
//     entityPrefab: Prefab = null!;

//     private entities: Node[] = [];
//     private readonly ENTITY_POOL_ID = 'ecs_entity';

//     async onLoad() {
//         // 为 ECS 实体创建节点池
//         nodePoolManager.createPool(this.ENTITY_POOL_ID, this.entityPrefab, {
//             preloadCount: 15,
//             maxCount: 100,
//             onNodeCreate: (node) => {
//                 // 创建时添加必要的 ECS 组件
//                 // node.addComponent(TransformComponent);
//                 // node.addComponent(RenderComponent);
//                 // node.addComponent(PhysicsComponent);
//             },
//             onNodeReuse: (node) => {
//                 // 重置实体状态
//                 this.resetEntity(node);
//             },
//         });

//         await nodePoolManager.preloadPool(this.ENTITY_POOL_ID);
//     }

//     /**
//      * 生成实体
//      */
//     public spawnEntity(x: number, y: number): Node | null {
//         const entity = nodePoolManager.getNode(this.ENTITY_POOL_ID);
//         if (entity) {
//             this.node.addChild(entity);
//             entity.setPosition(x, y, 0);
//             this.entities.push(entity);
//             return entity;
//         }
//         return null;
//     }

//     /**
//      * 销毁实体
//      */
//     public destroyEntity(entity: Node) {
//         const index = this.entities.indexOf(entity);
//         if (index !== -1) {
//             this.entities.splice(index, 1);
//             nodePoolManager.putNode(entity, this.ENTITY_POOL_ID);
//         }
//     }

//     /**
//      * 重置实体状态
//      */
//     private resetEntity(entity: Node) {
//         entity.setPosition(0, 0, 0);
//         entity.setRotation(0, 0, 0, 1);
//         entity.setScale(1, 1, 1);
//         entity.active = true;
        
//         // 重置 ECS 组件状态
//         // const transform = entity.getComponent(TransformComponent);
//         // if (transform) transform.reset();
//     }

//     onDestroy() {
//         this.entities.forEach(entity => {
//             nodePoolManager.putNode(entity, this.ENTITY_POOL_ID);
//         });
//         this.entities = [];
//     }
// }

